/**
 * 管理员用户管理控制器
 * 提供管理员用户管理的相关功能实现
 */

const AdminUser = require('../models/adminUser.model');
const { logInfo, logError, logWarning } = require('../../logger');
const bcrypt = require('bcrypt');
const { validationResult } = require('express-validator');

// 盐值轮数
const SALT_ROUNDS = 12;

/**
 * 获取所有管理员用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function getAllAdminUsers(req, res) {
  try {
    // 从查询参数获取分页信息
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const search = req.query.search || '';
    
    // 构建查询条件
    const query = {};
    if (search) {
      query.$or = [
        { username: { $regex: search, $options: 'i' } },
        { email: { $regex: search, $options: 'i' } }
      ];
    }
    
    // 获取管理员用户列表
    const adminUsers = await AdminUser.find(query)
      .skip((page - 1) * limit)
      .limit(limit)
      .sort({ createdAt: -1 });
    
    // 获取总数
    const total = await AdminUser.countDocuments(query);
    
    logInfo('获取管理员用户列表成功', { count: adminUsers.length });
    
    return res.status(200).json({
      success: true,
      message: '获取管理员用户列表成功',
      data: {
        adminUsers,
        pagination: {
          page,
          limit,
          total,
          pages: Math.ceil(total / limit)
        }
      }
    });
  } catch (error) {
    logError('获取管理员用户列表失败', { error: error.message });
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 根据ID获取管理员用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function getAdminUserById(req, res) {
  try {
    const { id } = req.params;
    
    // 查找管理员用户
    const adminUser = await AdminUser.findById(id);
    
    if (!adminUser) {
      logWarning('获取管理员用户详情失败：用户不存在', { id });
      return res.status(404).json({
        success: false,
        message: '管理员用户不存在'
      });
    }
    
    logInfo('获取管理员用户详情成功', { id });
    
    // 返回管理员用户信息（不包含密码）
    const userData = {
      id: adminUser._id,
      username: adminUser.username,
      email: adminUser.email,
      role: adminUser.role,
      status: adminUser.status,
      lastLogin: adminUser.lastLogin,
      createdAt: adminUser.createdAt,
      updatedAt: adminUser.updatedAt
    };
    
    return res.status(200).json({
      success: true,
      message: '获取管理员用户详情成功',
      data: {
        adminUser: userData
      }
    });
  } catch (error) {
    logError('获取管理员用户详情失败', { error: error.message, id: req.params.id });
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 创建新管理员用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function createAdminUser(req, res) {
  try {
    // 验证请求数据
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '请求数据验证失败',
        errors: errors.array()
      });
    }
    
    const { username, email, password, role } = req.body;
    
    // 检查用户名是否已存在
    const existingByUsername = await AdminUser.findOne({ username });
    if (existingByUsername) {
      logWarning('创建管理员用户失败：用户名已存在', { username });
      return res.status(409).json({
        success: false,
        message: '用户名已存在'
      });
    }
    
    // 检查邮箱是否已存在
    const existingByEmail = await AdminUser.findOne({ email });
    if (existingByEmail) {
      logWarning('创建管理员用户失败：邮箱已存在', { email });
      return res.status(409).json({
        success: false,
        message: '邮箱已存在'
      });
    }
    
    // 创建新管理员用户
    const newAdminUser = new AdminUser({
      username,
      email,
      password, // 密码将在模型中自动加密
      role: role || 'admin',
      status: 'active'
    });
    
    // 保存到数据库
    await newAdminUser.save();
    
    logInfo('创建管理员用户成功', { id: newAdminUser._id, username });
    
    // 返回管理员用户信息（不包含密码）
    const userData = {
      id: newAdminUser._id,
      username: newAdminUser.username,
      email: newAdminUser.email,
      role: newAdminUser.role,
      status: newAdminUser.status,
      createdAt: newAdminUser.createdAt,
      updatedAt: newAdminUser.updatedAt
    };
    
    return res.status(201).json({
      success: true,
      message: '创建管理员用户成功',
      data: {
        adminUser: userData
      }
    });
  } catch (error) {
    logError('创建管理员用户失败', { error: error.message });
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 更新管理员用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function updateAdminUser(req, res) {
  try {
    // 验证请求数据
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({
        success: false,
        message: '请求数据验证失败',
        errors: errors.array()
      });
    }
    
    const { id } = req.params;
    const { username, email, role, status } = req.body;
    
    // 查找要更新的管理员用户
    const adminUser = await AdminUser.findById(id);
    if (!adminUser) {
      logWarning('更新管理员用户失败：用户不存在', { id });
      return res.status(404).json({
        success: false,
        message: '管理员用户不存在'
      });
    }
    
    // 检查用户名是否已存在（排除当前用户）
    if (username && username !== adminUser.username) {
      const existingByUsername = await AdminUser.findOne({ 
        username, 
        _id: { $ne: id } 
      });
      if (existingByUsername) {
        logWarning('更新管理员用户失败：用户名已存在', { username });
        return res.status(409).json({
          success: false,
          message: '用户名已存在'
        });
      }
    }
    
    // 检查邮箱是否已存在（排除当前用户）
    if (email && email !== adminUser.email) {
      const existingByEmail = await AdminUser.findOne({ 
        email, 
        _id: { $ne: id } 
      });
      if (existingByEmail) {
        logWarning('更新管理员用户失败：邮箱已存在', { email });
        return res.status(409).json({
          success: false,
          message: '邮箱已存在'
        });
      }
    }
    
    // 更新管理员用户信息
    adminUser.username = username || adminUser.username;
    adminUser.email = email || adminUser.email;
    adminUser.role = role || adminUser.role;
    adminUser.status = status || adminUser.status;
    
    // 保存更新
    await adminUser.save();
    
    logInfo('更新管理员用户成功', { id });
    
    // 返回更新后的管理员用户信息（不包含密码）
    const userData = {
      id: adminUser._id,
      username: adminUser.username,
      email: adminUser.email,
      role: adminUser.role,
      status: adminUser.status,
      lastLogin: adminUser.lastLogin,
      createdAt: adminUser.createdAt,
      updatedAt: adminUser.updatedAt
    };
    
    return res.status(200).json({
      success: true,
      message: '更新管理员用户成功',
      data: {
        adminUser: userData
      }
    });
  } catch (error) {
    logError('更新管理员用户失败', { error: error.message, id: req.params.id });
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 删除管理员用户
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function deleteAdminUser(req, res) {
  try {
    const { id } = req.params;
    
    // 检查是否尝试删除自己
    if (id === req.user.id) {
      logWarning('删除管理员用户失败：不能删除自己', { id });
      return res.status(400).json({
        success: false,
        message: '不能删除自己的账户'
      });
    }
    
    // 查找要删除的管理员用户
    const adminUser = await AdminUser.findById(id);
    if (!adminUser) {
      logWarning('删除管理员用户失败：用户不存在', { id });
      return res.status(404).json({
        success: false,
        message: '管理员用户不存在'
      });
    }
    
    // 删除管理员用户
    await AdminUser.findByIdAndDelete(id);
    
    logInfo('删除管理员用户成功', { id });
    
    return res.status(200).json({
      success: true,
      message: '删除管理员用户成功'
    });
  } catch (error) {
    logError('删除管理员用户失败', { error: error.message, id: req.params.id });
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

/**
 * 修改管理员密码
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
async function changeAdminPassword(req, res) {
  try {
    const { id } = req.params;
    const { oldPassword, newPassword } = req.body;
    
    // 验证请求数据
    if (!oldPassword || !newPassword) {
      return res.status(400).json({
        success: false,
        message: '旧密码和新密码都是必需的'
      });
    }
    
    // 查找管理员用户
    const adminUser = await AdminUser.findById(id);
    if (!adminUser) {
      logWarning('修改管理员密码失败：用户不存在', { id });
      return res.status(404).json({
        success: false,
        message: '管理员用户不存在'
      });
    }
    
    // 验证旧密码
    const isOldPasswordValid = await adminUser.validatePassword(oldPassword);
    if (!isOldPasswordValid) {
      logWarning('修改管理员密码失败：旧密码错误', { id });
      return res.status(400).json({
        success: false,
        message: '旧密码错误'
      });
    }
    
    // 加密新密码
    const hashedPassword = await bcrypt.hash(newPassword, SALT_ROUNDS);
    
    // 更新密码
    adminUser.password = hashedPassword;
    await adminUser.save();
    
    logInfo('修改管理员密码成功', { id });
    
    return res.status(200).json({
      success: true,
      message: '修改密码成功'
    });
  } catch (error) {
    logError('修改管理员密码失败', { error: error.message, id: req.params.id });
    return res.status(500).json({
      success: false,
      message: '服务器内部错误'
    });
  }
}

module.exports = {
  getAllAdminUsers,
  getAdminUserById,
  createAdminUser,
  updateAdminUser,
  deleteAdminUser,
  changeAdminPassword
};